/**
 * 错误处理模块
 * 负责统一处理应用中的各种错误
 */

/**
 * 错误类型枚举
 */
const ErrorTypes = {
    // 系统错误
    SYSTEM: 'system_error',
    // 网络错误
    NETWORK: 'network_error',
    // 应用错误
    APPLICATION: 'application_error',
    // 用户操作错误
    USER: 'user_error',
    // 未知错误
    UNKNOWN: 'unknown_error'
};

/**
 * 处理错误
 * @param {Error|string} error - 错误对象或错误消息
 * @param {string} type - 错误类型，使用ErrorTypes中的值
 * @param {Object} context - 错误上下文信息
 * @param {Function} callback - 可选的回调函数
 */
function handleError(error, type = ErrorTypes.UNKNOWN, context = {}, callback = null) {
    // 构建错误信息对象
    const errorInfo = {
        message: error instanceof Error ? error.message : error,
        stack: error instanceof Error ? error.stack : null,
        type: type,
        timestamp: new Date().toISOString(),
        context: context
    };
    
    // 记录错误到控制台
    console.error(`[${type}] ${errorInfo.message}`, errorInfo);
    
    // 根据错误类型执行不同的处理逻辑
    switch (type) {
        case ErrorTypes.SYSTEM:
            // 系统错误处理
            showSystemErrorNotification(errorInfo);
            break;
            
        case ErrorTypes.APPLICATION:
            // 应用错误处理
            showApplicationErrorNotification(errorInfo);
            break;
            
        case ErrorTypes.USER:
            // 用户操作错误处理 - 通常只需要显示提示
            showUserErrorMessage(errorInfo);
            break;
            
        case ErrorTypes.NETWORK:
            // 网络错误处理
            showNetworkErrorNotification(errorInfo);
            break;
            
        default:
            // 未知错误处理
            showUnknownErrorNotification(errorInfo);
            break;
    }
    
    // 如果提供了回调函数，则调用
    if (typeof callback === 'function') {
        callback(errorInfo);
    }
    
    return errorInfo;
}

/**
 * 显示系统错误通知
 * @param {Object} errorInfo - 错误信息
 */
function showSystemErrorNotification(errorInfo) {
    showNotification('系统错误', errorInfo.message);
}

/**
 * 显示应用错误通知
 * @param {Object} errorInfo - 错误信息
 */
function showApplicationErrorNotification(errorInfo) {
    showNotification('应用错误', errorInfo.message);
}

/**
 * 显示网络错误通知
 * @param {Object} errorInfo - 错误信息
 */
function showNetworkErrorNotification(errorInfo) {
    showNotification('网络错误', errorInfo.message);
}

/**
 * 显示未知错误通知
 * @param {Object} errorInfo - 错误信息
 */
function showUnknownErrorNotification(errorInfo) {
    showNotification('发生错误', errorInfo.message);
}

/**
 * 显示用户错误消息
 * @param {Object} errorInfo - 错误信息
 */
function showUserErrorMessage(errorInfo) {
    // 使用alert显示用户操作错误
    alert(errorInfo.message);
}

/**
 * 显示通知
 * @param {string} title - 通知标题
 * @param {string} body - 通知内容
 */
function showNotification(title, body) {
    // 检查通知API是否可用
    if ('Notification' in window) {
        // 检查权限
        if (Notification.permission === 'granted') {
            new Notification(title, { body });
        } else if (Notification.permission !== 'denied') {
            // 请求权限
            Notification.requestPermission().then(permission => {
                if (permission === 'granted') {
                    new Notification(title, { body });
                }
            });
        }
    } else {
        // 如果通知API不可用，回退到控制台
        console.warn(`通知: ${title} - ${body}`);
    }
}

/**
 * 尝试执行函数并处理可能的错误
 * @param {Function} fn - 要执行的函数
 * @param {Object} options - 选项
 * @param {string} options.errorType - 错误类型
 * @param {Object} options.context - 错误上下文
 * @param {Function} options.onError - 错误回调
 * @param {Function} options.onSuccess - 成功回调
 * @returns {*} 函数执行结果
 */
function tryCatch(fn, options = {}) {
    const {
        errorType = ErrorTypes.UNKNOWN,
        context = {},
        onError = null,
        onSuccess = null
    } = options;
    
    try {
        const result = fn();
        
        // 处理Promise结果
        if (result instanceof Promise) {
            return result
                .then(data => {
                    if (typeof onSuccess === 'function') {
                        onSuccess(data);
                    }
                    return data;
                })
                .catch(error => {
                    handleError(error, errorType, context, onError);
                    throw error; // 重新抛出错误以便调用者可以继续处理
                });
        }
        
        // 处理非Promise结果
        if (typeof onSuccess === 'function') {
            onSuccess(result);
        }
        return result;
    } catch (error) {
        handleError(error, errorType, context, onError);
        throw error; // 重新抛出错误以便调用者可以继续处理
    }
}

// 导出模块
module.exports = {
    ErrorTypes,
    handleError,
    tryCatch
};